home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / actionrp / lrogue0.1 / lrogue0 / rogue / object.c < prev    next >
C/C++ Source or Header  |  1992-09-26  |  16KB  |  774 lines
  1. /*
  2.  * object.c
  3.  *
  4.  * This source herein may be modified and/or distributed by anybody who
  5.  * so desires, with the following restrictions:
  6.  *    1.)  No portion of this notice shall be removed.
  7.  *    2.)  Credit shall not be taken for the creation of this source.
  8.  *    3.)  This code is not to be traded, sold, or used for personal
  9.  *         gain or profit.
  10.  *
  11.  */
  12.  
  13. #ifndef CURSES
  14. #include <curses.h>
  15. #endif CURSES
  16. #include "rogue.h"
  17.  
  18. object level_objects;
  19. unsigned short dungeon[DROWS][DCOLS];
  20. short foods = 0;
  21. short party_counter;
  22. object *free_list = (object *) 0;
  23. char *fruit = "slime-mold ";
  24.  
  25. fighter rogue = {
  26.     0, 0,        /* armor, weapon */
  27.     0, 0,        /* rings */
  28.     INIT_HP,    /* Hp current */
  29.     INIT_HP,    /* Hp max */
  30.     16, 16,        /* Str */
  31.     {0},        /* pack */
  32.     0,            /* gold */
  33.     1, 0,        /* exp, exp_points */
  34.     0, 0,        /* row, col */
  35.     '@',        /* char */
  36.     1250        /* moves */
  37. };
  38.  
  39. struct id id_potions[POTIONS] = {
  40. {100, "blue \0                           ", "of increase strength ", 0},
  41. {250, "red \0                            ", "of restore strength ", 0},
  42. {100, "green \0                          ", "of healing ", 0},
  43. {200, "grey \0                           ", "of extra healing ", 0},
  44.  {10, "brown \0                          ", "of poison ", 0},
  45. {300, "clear \0                          ", "of raise level ", 0},
  46.  {10, "pink \0                           ", "of blindness ", 0},
  47.  {25, "white \0                          ", "of hallucination ", 0},
  48. {100, "purple \0                         ", "of detect monster ", 0},
  49. {100, "black \0                          ", "of detect things ", 0},
  50.  {10, "yellow \0                         ", "of confusion ", 0},
  51.  {80, "plaid \0                          ", "of levitation ", 0},
  52. {150, "burgundy \0                       ", "of haste self ", 0},
  53. {145, "beige \0                          ", "of see invisible ", 0}
  54. };
  55.  
  56. struct id id_scrolls[SCROLLS] = {
  57. {505, "                                   ", "of protect armor ", 0},
  58. {200, "                                   ", "of hold monster ", 0},
  59. {235, "                                   ", "of enchant weapon ", 0},
  60. {235, "                                   ", "of enchant armor ", 0},
  61. {175, "                                   ", "of identify ", 0},
  62. {190, "                                   ", "of teleportation ", 0},
  63.  {25, "                                   ", "of sleep ", 0},
  64. {610, "                                   ", "of scare monster ", 0},
  65. {210, "                                   ", "of remove curse ", 0},
  66. {100, "                                   ", "of create monster ",0},
  67.  {25, "                                   ", "of aggravate monster ",0},
  68. {180, "                                   ", "of magic mapping ",0}
  69. };
  70.  
  71. struct id id_weapons[WEAPONS] = {
  72.     {150, "short bow ", "", 0},
  73.       {8, "darts ", "", 0},
  74.      {15, "arrows ", "", 0},
  75.      {27, "daggers ", "", 0},
  76.      {35, "shurikens ", "", 0},
  77.     {360, "mace ", "", 0},
  78.     {470, "long sword ", "", 0},
  79.     {580, "two-handed sword ", "", 0}
  80. };
  81.  
  82. struct id id_armors[ARMORS] = {
  83.     {300, "leather armor ", "", (UNIDENTIFIED)},
  84.     {300, "ring mail ", "", (UNIDENTIFIED)},
  85.     {400, "scale mail ", "", (UNIDENTIFIED)},
  86.     {500, "chain mail ", "", (UNIDENTIFIED)},
  87.     {600, "banded mail ", "", (UNIDENTIFIED)},
  88.     {600, "splint mail ", "", (UNIDENTIFIED)},
  89.     {700, "plate mail ", "", (UNIDENTIFIED)}
  90. };
  91.  
  92. struct id id_wands[WANDS] = {
  93.      {25, "                                 ", "of teleport away ",0},
  94.      {50, "                                 ", "of slow monster ", 0},
  95.      {45, "                                 ", "of confuse monster ",0},
  96.       {8, "                                 ", "of invisibility ",0},
  97.      {55, "                                 ", "of polymorph ",0},
  98.       {2, "                                 ", "of haste monster ",0},
  99.      {25, "                                 ", "of sleep ",0},
  100.      {20, "                                 ", "of magic missile ",0},
  101.      {20, "                                 ", "of cancellation ",0},
  102.       {0, "                                 ", "of do nothing ",0}
  103. };
  104.  
  105. struct id id_rings[RINGS] = {
  106.      {250, "                                 ", "of stealth ",0},
  107.      {100, "                                 ", "of teleportation ", 0},
  108.      {255, "                                 ", "of regeneration ",0},
  109.      {295, "                                 ", "of slow digestion ",0},
  110.      {200, "                                 ", "of add strength ",0},
  111.      {250, "                                 ", "of sustain strength ",0},
  112.      {250, "                                 ", "of dexterity ",0},
  113.       {25, "                                 ", "of adornment ",0},
  114.      {300, "                                 ", "of see invisible ",0},
  115.      {290, "                                 ", "of maintain armor ",0},
  116.      {270, "                                 ", "of searching ",0},
  117. };
  118.  
  119. extern short cur_level, max_level;
  120. extern short party_room;
  121. extern char *error_file;
  122. extern boolean is_wood[];
  123.  
  124. put_objects()
  125. {
  126.     short i, n;
  127.     object *obj;
  128.  
  129.     if (cur_level < max_level) {
  130.         return;
  131.     }
  132.     n = coin_toss() ? get_rand(2, 4) : get_rand(3, 5);
  133.     while (rand_percent(33)) {
  134.         n++;
  135.     }
  136.     if (cur_level == party_counter) {
  137.         make_party();
  138.         party_counter = next_party();
  139.     }
  140.     for (i = 0; i < n; i++) {
  141.         obj = gr_object();
  142.         rand_place(obj);
  143.     }
  144.     put_gold();
  145. }
  146.  
  147. put_gold()
  148. {
  149.     short i, j;
  150.     short row,col;
  151.     boolean is_maze, is_room;
  152.  
  153.     for (i = 0; i < MAXROOMS; i++) {
  154.         is_maze = (rooms[i].is_room & R_MAZE) ? 1 : 0;
  155.         is_room = (rooms[i].is_room & R_ROOM) ? 1 : 0;
  156.  
  157.         if (!(is_room || is_maze)) {
  158.             continue;
  159.         }
  160.         if (is_maze || rand_percent(GOLD_PERCENT)) {
  161.             for (j = 0; j < 50; j++) {
  162.                 row = get_rand(rooms[i].top_row+1,
  163.                 rooms[i].bottom_row-1);
  164.                 col = get_rand(rooms[i].left_col+1,
  165.                 rooms[i].right_col-1);
  166.                 if ((dungeon[row][col] == FLOOR) ||
  167.                     (dungeon[row][col] == TUNNEL)) {
  168.                     plant_gold(row, col, is_maze);
  169.                     break;
  170.                 }
  171.             }
  172.         }
  173.     }
  174. }
  175.  
  176. plant_gold(row, col, is_maze)
  177. short row, col;
  178. boolean is_maze;
  179. {
  180.     object *obj;
  181.  
  182.     obj = alloc_object();
  183.     obj->row = row; obj->col = col;
  184.     obj->what_is = GOLD;
  185.     obj->quantity = get_rand((2 * cur_level), (16 * cur_level));
  186.     if (is_maze) {
  187.         obj->quantity += obj->quantity / 2;
  188.     }
  189.     dungeon[row][col] |= OBJECT;
  190.     (void) add_to_pack(obj, &level_objects, 0);
  191. }
  192.  
  193. place_at(obj, row, col)
  194. object *obj;
  195. {
  196.     obj->row = row;
  197.     obj->col = col;
  198.     dungeon[row][col] |= OBJECT;
  199.     (void) add_to_pack(obj, &level_objects, 0);
  200. }
  201.  
  202. object *
  203. object_at(pack, row, col)
  204. register object *pack;
  205. short row, col;
  206. {
  207.     object *obj;
  208.  
  209.     obj = pack->next_object;
  210.  
  211.     while (obj && ((obj->row != row) || (obj->col != col))) {
  212.         obj = obj->next_object;
  213.     }
  214.     return(obj);
  215. }
  216.  
  217. object *
  218. get_letter_object(ch)
  219. {
  220.     object *obj;
  221.  
  222.     obj = rogue.pack.next_object;
  223.  
  224.     while (obj && (obj->ichar != ch)) {
  225.         obj = obj->next_object;
  226.     }
  227.     return(obj);
  228. }
  229.  
  230. free_stuff(objlist)
  231. object *objlist;
  232. {
  233.     object *obj;
  234.  
  235.     while (objlist->next_object) {
  236.         obj = objlist->next_object;
  237.         objlist->next_object =
  238.             objlist->next_object->next_object;
  239.         free_object(obj);
  240.     }
  241. }
  242.  
  243. #ifdef OLD
  244. free_free_list()
  245. {
  246.     object *obj;
  247.  
  248.     while (free_list) {
  249.         obj = free_list;
  250.         free_list = free_list->next_object;
  251.         free_object(obj);
  252.     }
  253. }
  254.  
  255. #endif
  256.  
  257. char *
  258. name_of(obj)
  259. object *obj;
  260. {
  261.     char *retstring;
  262.  
  263.     switch(obj->what_is) {
  264.     case SCROLL:
  265.         retstring = obj->quantity > 1 ? "scrolls " : "scroll ";
  266.         break;
  267.     case POTION:
  268.         retstring = obj->quantity > 1 ? "potions " : "potion ";
  269.         break;
  270.     case FOOD:
  271.         if (obj->which_kind == RATION) {
  272.             retstring = "food ";
  273.         } else {
  274.             retstring = fruit;
  275.         }
  276.         break;
  277.     case WAND:
  278.         retstring = is_wood[obj->which_kind] ? "staff " : "wand ";
  279.         break;
  280.     case WEAPON:
  281.         switch(obj->which_kind) {
  282.         case DART:
  283.             retstring=obj->quantity > 1 ? "darts " : "dart ";
  284.             break;
  285.         case ARROW:
  286.             retstring=obj->quantity > 1 ? "arrows " : "arrow ";
  287.             break;
  288.         case DAGGER:
  289.             retstring=obj->quantity > 1 ? "daggers " : "dagger ";
  290.             break;
  291.         case SHURIKEN:
  292.             retstring=obj->quantity > 1?"shurikens ":"shuriken ";
  293.             break;
  294.         default:
  295.             retstring = id_weapons[obj->which_kind].title;
  296.         }
  297.         break;
  298.     case ARMOR:
  299.         retstring = "armor ";
  300.         break;
  301.     case RING:
  302.             retstring = "ring ";
  303.         break;
  304.     case AMULET:
  305.         retstring = "amulet ";
  306.         break;
  307.     default:
  308.         retstring = "unknown ";
  309.         break;
  310.     }
  311.     return(retstring);
  312. }
  313.  
  314. object *
  315. gr_object()
  316. {
  317.     object *obj;
  318.  
  319.     obj = alloc_object();
  320.  
  321.     if (foods < (cur_level/2 )) {
  322.         obj->what_is = FOOD;
  323.         foods++;
  324.     } else {
  325.         obj->what_is = gr_what_is();
  326.     }
  327.     switch(obj->what_is) {
  328.     case SCROLL:
  329.         gr_scroll(obj);
  330.         break;
  331.     case POTION:
  332.         gr_potion(obj);
  333.         break;
  334.     case WEAPON:
  335.         gr_weapon(obj, 1);
  336.         break;
  337.     case ARMOR:
  338.         gr_armor(obj);
  339.         break;
  340.     case WAND:
  341.         gr_wand(obj);
  342.         break;
  343.     case FOOD:
  344.         get_food(obj, 0);
  345.         break;
  346.     case RING:
  347.         gr_ring(obj, 1);
  348.         break;
  349.     }
  350.     return(obj);
  351. }
  352.  
  353. unsigned short
  354. gr_what_is()
  355. {
  356.     short percent;
  357.     unsigned short what_is;
  358.  
  359.     percent = get_rand(1, 91);
  360.  
  361.     if (percent <= 30) {
  362.         what_is = SCROLL;
  363.     } else if (percent <= 60) {
  364.         what_is = POTION;
  365.     } else if (percent <= 64) {
  366.         what_is = WAND;
  367.     } else if (percent <= 74) {
  368.         what_is = WEAPON;
  369.     } else if (percent <= 83) {
  370.         what_is = ARMOR;
  371.     } else if (percent <= 88) {
  372.         what_is = FOOD;
  373.     } else {
  374.         what_is = RING;
  375.     }
  376.     return(what_is);
  377. }
  378.  
  379. gr_scroll(obj)
  380. object *obj;
  381. {
  382.     short percent;
  383.  
  384.     percent = get_rand(0, 85);
  385.  
  386.     obj->what_is = SCROLL;
  387.  
  388.     if (percent <= 5) {
  389.         obj->which_kind = PROTECT_ARMOR;
  390.     } else if (percent <= 11) {
  391.         obj->which_kind = HOLD_MONSTER;
  392.     } else if (percent <= 20) {
  393.         obj->which_kind = CREATE_MONSTER;
  394.     } else if (percent <= 35) {
  395.         obj->which_kind = IDENTIFY;
  396.     } else if (percent <= 43) {
  397.         obj->which_kind = TELEPORT;
  398.     } else if (percent <= 50) {
  399.         obj->which_kind = SLEEP;
  400.     } else if (percent <= 55) {
  401.         obj->which_kind = SCARE_MONSTER;
  402.     } else if (percent <= 64) {
  403.         obj->which_kind = REMOVE_CURSE;
  404.     } else if (percent <= 69) {
  405.         obj->which_kind = ENCH_ARMOR;
  406.     } else if (percent <= 74) {
  407.         obj->which_kind = ENCH_WEAPON;
  408.     } else if (percent <= 80) {
  409.         obj->which_kind = AGGRAVATE_MONSTER;
  410.     } else {
  411.         obj->which_kind = MAGIC_MAPPING;
  412.     }
  413. }
  414.  
  415. gr_potion(obj)
  416. object *obj;
  417. {
  418.     short percent;
  419.  
  420.     percent = get_rand(1, 118);
  421.  
  422.     obj->what_is = POTION;
  423.  
  424.     if (percent <= 5) {
  425.         obj->which_kind = RAISE_LEVEL;
  426.     } else if (percent <= 15) {
  427.         obj->which_kind = DETECT_OBJECTS;
  428.     } else if (percent <= 25) {
  429.         obj->which_kind = DETECT_MONSTER;
  430.     } else if (percent <= 35) {
  431.         obj->which_kind = INCREASE_STRENGTH;
  432.     } else if (percent <= 45) {
  433.         obj->which_kind = RESTORE_STRENGTH;
  434.     } else if (percent <= 55) {
  435.         obj->which_kind = HEALING;
  436.     } else if (percent <= 65) {
  437.         obj->which_kind = EXTRA_HEALING;
  438.     } else if (percent <= 75) {
  439.         obj->which_kind = BLINDNESS;
  440.     } else if (percent <= 85) {
  441.         obj->which_kind = HALLUCINATION;
  442.     } else if (percent <= 95) {
  443.         obj->which_kind = CONFUSION;
  444.     } else if (percent <= 105) {
  445.         obj->which_kind = POISON;
  446.     } else if (percent <= 110) {
  447.         obj->which_kind = LEVITATION;
  448.     } else if (percent <= 114) {
  449.         obj->which_kind = HASTE_SELF;
  450.     } else {
  451.         obj->which_kind = SEE_INVISIBLE;
  452.     }
  453. }
  454.  
  455. gr_weapon(obj, assign_wk)
  456. object *obj;
  457. int assign_wk;
  458. {
  459.     short percent;
  460.     short i;
  461.     short blessing, increment;
  462.  
  463.     obj->what_is = WEAPON;
  464.     if (assign_wk) {
  465.         obj->which_kind = get_rand(0, (WEAPONS - 1));
  466.     }
  467.     if ((obj->which_kind == ARROW) || (obj->which_kind == DAGGER) ||
  468.         (obj->which_kind == SHURIKEN) | (obj->which_kind == DART)) {
  469.         obj->quantity = get_rand(3, 15);
  470.         obj->quiver = get_rand(0, 126);
  471.     } else {
  472.         obj->quantity = 1;
  473.     }
  474.     obj->hit_enchant = obj->d_enchant = 0;
  475.  
  476.     percent = get_rand(1, 96);
  477.     blessing = get_rand(1, 3);
  478.  
  479.     if (percent <= 16) {
  480.         increment = 1;
  481.     } else if (percent <= 32) {
  482.         increment = -1;
  483.         obj->is_cursed = 1;
  484.     }
  485.     if (percent <= 32) {
  486.         for (i = 0; i < blessing; i++) {
  487.             if (coin_toss()) {
  488.                 obj->hit_enchant += increment;
  489.             } else {
  490.                 obj->d_enchant += increment;
  491.             }
  492.         }
  493.     }
  494.     switch(obj->which_kind) {
  495.     case BOW:
  496.     case DART:
  497.         obj->damage = "1d1";
  498.         break;
  499.     case ARROW:
  500.         obj->damage = "1d2";
  501.         break;
  502.     case DAGGER:
  503.         obj->damage = "1d3";
  504.         break;
  505.     case SHURIKEN:
  506.         obj->damage = "1d4";
  507.         break;
  508.     case MACE:
  509.         obj->damage = "2d3";
  510.         break;
  511.     case LONG_SWORD:
  512.         obj->damage = "3d4";
  513.         break;
  514.     case TWO_HANDED_SWORD:
  515.         obj->damage = "4d5";
  516.         break;
  517.     }
  518. }
  519.  
  520. gr_armor(obj)
  521. object *obj;
  522. {
  523.     short percent;
  524.     short blessing;
  525.  
  526.     obj->what_is = ARMOR;
  527.     obj->which_kind = get_rand(0, (ARMORS - 1));
  528.     obj->class = obj->which_kind + 2;
  529.     if ((obj->which_kind == PLATE) || (obj->which_kind == SPLINT)) {
  530.         obj->class--;
  531.     }
  532.     obj->is_protected = 0;
  533.     obj->d_enchant = 0;
  534.  
  535.     percent = get_rand(1, 100);
  536.     blessing = get_rand(1, 3);
  537.  
  538.     if (percent <= 16) {
  539.         obj->is_cursed = 1;
  540.         obj->d_enchant -= blessing;
  541.     } else if (percent <= 33) {
  542.         obj->d_enchant += blessing;
  543.     }
  544. }
  545.  
  546. gr_wand(obj)
  547. object *obj;
  548. {
  549.     obj->what_is = WAND;
  550.     obj->which_kind = get_rand(0, (WANDS - 1));
  551.     if (obj->which_kind == MAGIC_MISSILE) {
  552.         obj->class = get_rand(6, 12);
  553.     } else if (obj->which_kind == CANCELLATION) {
  554.         obj->class = get_rand(5, 9);
  555.     } else {
  556.         obj->class = get_rand(3, 6);
  557.     }
  558. }
  559.  
  560. get_food(obj, force_ration)
  561. object *obj;
  562. boolean force_ration;
  563. {
  564.     obj->what_is = FOOD;
  565.  
  566.     if (force_ration || rand_percent(80)) {
  567.         obj->which_kind = RATION;
  568.     } else {
  569.         obj->which_kind = FRUIT;
  570.     }
  571. }
  572.  
  573. put_stairs()
  574. {
  575.     short row, col;
  576.  
  577.     gr_row_col(&row, &col, (FLOOR | TUNNEL));
  578.     dungeon[row][col] |= STAIRS;
  579. }
  580.  
  581. get_armor_class(obj)
  582. object *obj;
  583. {
  584.     if (obj) {
  585.         return(obj->class + obj->d_enchant);
  586.     }
  587.     return(0);
  588. }
  589.  
  590. object *
  591. alloc_object()
  592. {
  593.     object *obj;
  594.  
  595.     if (free_list) {
  596.         obj = free_list;
  597.         free_list = free_list->next_object;
  598.     } else if (!(obj = (object *) md_malloc(sizeof(object)))) {
  599. /*            free_free_list();    */
  600.             message("cannot allocate object, saving game", 0);
  601.             save_into_file(error_file);
  602.     }
  603.     obj->quantity = 1;
  604.     obj->ichar = 'L';
  605.     obj->picked_up = obj->is_cursed = 0;
  606.     obj->in_use_flags = NOT_USED;
  607.     obj->identified = UNIDENTIFIED;
  608.     obj->damage = "1d1";
  609.     return(obj);
  610. }
  611.  
  612. free_object(obj)
  613. object *obj;
  614. {
  615.     obj->next_object = free_list;
  616.     free_list = obj;
  617. }
  618.  
  619. make_party()
  620. {
  621.     short n;
  622.  
  623.     party_room = gr_room();
  624.  
  625.     n = rand_percent(99) ? party_objects(party_room) : 11;
  626.     if (rand_percent(99)) {
  627.         party_monsters(party_room, n);
  628.     }
  629. }
  630.  
  631. show_objects()
  632. {
  633.     object *obj;
  634.     short mc, rc, row, col;
  635.     object *monster;
  636.  
  637.     obj = level_objects.next_object;
  638.  
  639.     while (obj) {
  640.         row = obj->row;
  641.         col = obj->col;
  642.  
  643.         rc = get_mask_char(obj->what_is);
  644.  
  645.         if (dungeon[row][col] & MONSTER) {
  646.             if (monster = object_at(&level_monsters, row, col)) {
  647.                 monster->trail_char = rc;
  648.             }
  649.         }
  650.         mc = mvinch(row, col);
  651.         if (((mc < 'A') || (mc > 'Z')) &&
  652.             ((row != rogue.row) || (col != rogue.col))) {
  653.             mvaddch(row, col, rc);
  654.         }
  655.         obj = obj->next_object;
  656.     }
  657.  
  658.     monster = level_monsters.next_object;
  659.  
  660.     while (monster) {
  661.         if (monster->m_flags & IMITATES) {
  662.             mvaddch(monster->row, monster->col, (int) monster->disguise);
  663.         }
  664.         monster = monster->next_monster;
  665.     }
  666. }
  667.  
  668. put_amulet()
  669. {
  670.     object *obj;
  671.  
  672.     obj = alloc_object();
  673.     obj->what_is = AMULET;
  674.     rand_place(obj);
  675. }
  676.  
  677. rand_place(obj)
  678. object *obj;
  679. {
  680.     short row, col;
  681.  
  682.     gr_row_col(&row, &col, (FLOOR | TUNNEL));
  683.     place_at(obj, row, col);
  684.  
  685. }
  686.  
  687. new_object_for_wizard()
  688. {
  689.     short ch, max, wk;
  690.     object *obj;
  691.     char buf[80];
  692.  
  693.     if (pack_count((object *) 0) >= MAX_PACK_COUNT) {
  694.         message("pack full", 0);
  695.         return;
  696.     }
  697.     message("type of object?", 0);
  698.  
  699.     while (r_index("!?:)]=/,\033", (ch = rgetchar()), 0) == -1) {
  700.         sound_bell();
  701.     }
  702.     check_message();
  703.  
  704.     if (ch == '\033') {
  705.         return;
  706.     }
  707.     obj = alloc_object();
  708.  
  709.     switch(ch) {
  710.     case '!':
  711.         obj->what_is = POTION;
  712.         max = POTIONS - 1;
  713.         break;
  714.     case '?':
  715.         obj->what_is = SCROLL;
  716.         max = SCROLLS - 1;
  717.         break;
  718.     case ',':
  719.         obj->what_is = AMULET;
  720.         break;
  721.     case ':':
  722.         get_food(obj, 0);
  723.         break;
  724.     case ')':
  725.         gr_weapon(obj, 0);
  726.         max = WEAPONS - 1;
  727.         break;
  728.     case ']':
  729.         gr_armor(obj);
  730.         max = ARMORS - 1;
  731.         break;
  732.     case '/':
  733.         gr_wand(obj);
  734.         max = WANDS - 1;
  735.         break;
  736.     case '=':
  737.         max = RINGS - 1;
  738.         obj->what_is = RING;
  739.         break;
  740.     }
  741.     if ((ch != ',') && (ch != ':')) {
  742. GIL:
  743.         if (get_input_line("which kind?", "", buf, "", 0, 1)) {
  744.             wk = get_number(buf);
  745.             if ((wk >= 0) && (wk <= max)) {
  746.                 obj->which_kind = (unsigned short) wk;
  747.                 if (obj->what_is == RING) {
  748.                     gr_ring(obj, 0);
  749.                 }
  750.             } else {
  751.                 sound_bell();
  752.                 goto GIL;
  753.             }
  754.         } else {
  755.             free_object(obj);
  756.             return;
  757.         }
  758.     }
  759.     get_desc(obj, buf);
  760.     message(buf, 0);
  761.     (void) add_to_pack(obj, &rogue.pack, 1);
  762. }
  763.  
  764. next_party()
  765. {
  766.     int n;
  767.  
  768.     n = cur_level;
  769.     while (n % PARTY_TIME) {
  770.         n++;
  771.     }
  772.     return(get_rand((n + 1), (n + PARTY_TIME)));
  773. }
  774.